home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / lib / python2.6 / runpy.py < prev    next >
Text File  |  2009-11-02  |  5KB  |  150 lines
  1. """runpy.py - locating and running Python code using the module namespace
  2.  
  3. Provides support for locating and running Python scripts using the Python
  4. module namespace instead of the native filesystem.
  5.  
  6. This allows Python code to play nicely with non-filesystem based PEP 302
  7. importers when locating support scripts as well as when importing modules.
  8. """
  9. # Written by Nick Coghlan <ncoghlan at gmail.com>
  10. #    to implement PEP 338 (Executing Modules as Scripts)
  11.  
  12. import sys
  13. import imp
  14. try:
  15.     from imp import get_loader
  16. except ImportError:
  17.     from pkgutil import get_loader
  18.  
  19. __all__ = [
  20.     "run_module",
  21. ]
  22.  
  23.  
  24. def _run_code(code, run_globals, init_globals=None,
  25.               mod_name=None, mod_fname=None,
  26.               mod_loader=None, pkg_name=None):
  27.     """Helper for _run_module_code"""
  28.     if init_globals is not None:
  29.         run_globals.update(init_globals)
  30.     run_globals.update(__name__ = mod_name,
  31.                        __file__ = mod_fname,
  32.                        __loader__ = mod_loader,
  33.                        __package__ = pkg_name)
  34.     exec code in run_globals
  35.     return run_globals
  36.  
  37. def _run_module_code(code, init_globals=None,
  38.                     mod_name=None, mod_fname=None,
  39.                     mod_loader=None, pkg_name=None):
  40.     """Helper for run_module"""
  41.     # Set up the top level namespace dictionary
  42.     temp_module = imp.new_module(mod_name)
  43.     mod_globals = temp_module.__dict__
  44.     # Modify sys.argv[0] and sys.module[mod_name]
  45.     saved_argv0 = sys.argv[0]
  46.     restore_module = mod_name in sys.modules
  47.     if restore_module:
  48.         saved_module = sys.modules[mod_name]
  49.     sys.argv[0] = mod_fname
  50.     sys.modules[mod_name] = temp_module
  51.     try:
  52.         _run_code(code, mod_globals, init_globals,
  53.                     mod_name, mod_fname,
  54.                     mod_loader, pkg_name)
  55.     finally:
  56.         sys.argv[0] = saved_argv0
  57.         if restore_module:
  58.             sys.modules[mod_name] = saved_module
  59.         else:
  60.             del sys.modules[mod_name]
  61.     # Copy the globals of the temporary module, as they
  62.     # may be cleared when the temporary module goes away
  63.     return mod_globals.copy()
  64.  
  65.  
  66. # This helper is needed due to a missing component in the PEP 302
  67. # loader protocol (specifically, "get_filename" is non-standard)
  68. # Since we can't introduce new features in maintenance releases,
  69. # support was added to zipimporter under the name '_get_filename'
  70. def _get_filename(loader, mod_name):
  71.     for attr in ("get_filename", "_get_filename"):
  72.         meth = getattr(loader, attr, None)
  73.         if meth is not None:
  74.             return meth(mod_name)
  75.     return None
  76.  
  77. # Helper to get the loader, code and filename for a module
  78. def _get_module_details(mod_name):
  79.     loader = get_loader(mod_name)
  80.     if loader is None:
  81.         raise ImportError("No module named %s" % mod_name)
  82.     if loader.is_package(mod_name):
  83.         raise ImportError(("%s is a package and cannot " +
  84.                           "be directly executed") % mod_name)
  85.     code = loader.get_code(mod_name)
  86.     if code is None:
  87.         raise ImportError("No code object available for %s" % mod_name)
  88.     filename = _get_filename(loader, mod_name)
  89.     return loader, code, filename
  90.  
  91.  
  92. # XXX ncoghlan: Should this be documented and made public?
  93. # (Current thoughts: don't repeat the mistake that lead to its
  94. # creation when run_module() no longer met the needs of
  95. # mainmodule.c, but couldn't be changed because it was public)
  96. def _run_module_as_main(mod_name, set_argv0=True):
  97.     """Runs the designated module in the __main__ namespace
  98.  
  99.        These __*__ magic variables will be overwritten:
  100.            __file__
  101.            __loader__
  102.     """
  103.     try:
  104.         loader, code, fname = _get_module_details(mod_name)
  105.     except ImportError as exc:
  106.         # Try to provide a good error message
  107.         # for directories, zip files and the -m switch
  108.         if set_argv0:
  109.             # For -m switch, just disply the exception
  110.             info = str(exc)
  111.         else:
  112.             # For directories/zipfiles, let the user
  113.             # know what the code was looking for
  114.             info = "can't find '__main__.py' in %r" % sys.argv[0]
  115.         msg = "%s: %s" % (sys.executable, info)
  116.         sys.exit(msg)
  117.     pkg_name = mod_name.rpartition('.')[0]
  118.     main_globals = sys.modules["__main__"].__dict__
  119.     if set_argv0:
  120.         sys.argv[0] = fname
  121.     return _run_code(code, main_globals, None,
  122.                      "__main__", fname, loader, pkg_name)
  123.  
  124. def run_module(mod_name, init_globals=None,
  125.                run_name=None, alter_sys=False):
  126.     """Execute a module's code without importing it
  127.  
  128.        Returns the resulting top level namespace dictionary
  129.     """
  130.     loader, code, fname = _get_module_details(mod_name)
  131.     if run_name is None:
  132.         run_name = mod_name
  133.     pkg_name = mod_name.rpartition('.')[0]
  134.     if alter_sys:
  135.         return _run_module_code(code, init_globals, run_name,
  136.                                 fname, loader, pkg_name)
  137.     else:
  138.         # Leave the sys module alone
  139.         return _run_code(code, {}, init_globals, run_name,
  140.                          fname, loader, pkg_name)
  141.  
  142.  
  143. if __name__ == "__main__":
  144.     # Run the module specified as the next command line argument
  145.     if len(sys.argv) < 2:
  146.         print >> sys.stderr, "No module specified for execution"
  147.     else:
  148.         del sys.argv[0] # Make the requested module sys.argv[0]
  149.         _run_module_as_main(sys.argv[0])
  150.